home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / kyugo.c < prev    next >
C/C++ Source or Header  |  2000-05-04  |  6KB  |  227 lines
  1. #include "driver.h"
  2. #include "vidhrdw/generic.h"
  3.  
  4.  
  5. unsigned char *kyugo_videoram;
  6. size_t kyugo_videoram_size;
  7. unsigned char *kyugo_back_scrollY_lo;
  8. unsigned char *kyugo_back_scrollX;
  9.  
  10. static unsigned char kyugo_back_scrollY_hi;
  11. static int palbank,frontcolor;
  12. static int flipscreen;
  13. static const unsigned char *color_codes;
  14.  
  15.  
  16. /***************************************************************************
  17.  
  18.   Convert the color PROMs into a more useable format.
  19.  
  20. ***************************************************************************/
  21. void kyugo_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  22. {
  23.     int i;
  24.  
  25.  
  26.     for (i = 0;i < Machine->drv->total_colors;i++)
  27.     {
  28.         int bit0,bit1,bit2,bit3;
  29.  
  30.         /* red component */
  31.         bit0 = (color_prom[0] >> 0) & 0x01;
  32.         bit1 = (color_prom[0] >> 1) & 0x01;
  33.         bit2 = (color_prom[0] >> 2) & 0x01;
  34.         bit3 = (color_prom[0] >> 3) & 0x01;
  35.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  36.         /* green component */
  37.         bit0 = (color_prom[Machine->drv->total_colors] >> 0) & 0x01;
  38.         bit1 = (color_prom[Machine->drv->total_colors] >> 1) & 0x01;
  39.         bit2 = (color_prom[Machine->drv->total_colors] >> 2) & 0x01;
  40.         bit3 = (color_prom[Machine->drv->total_colors] >> 3) & 0x01;
  41.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  42.         /* blue component */
  43.         bit0 = (color_prom[2*Machine->drv->total_colors] >> 0) & 0x01;
  44.         bit1 = (color_prom[2*Machine->drv->total_colors] >> 1) & 0x01;
  45.         bit2 = (color_prom[2*Machine->drv->total_colors] >> 2) & 0x01;
  46.         bit3 = (color_prom[2*Machine->drv->total_colors] >> 3) & 0x01;
  47.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  48.         color_prom++;
  49.     }
  50.  
  51.     color_prom += 2*Machine->drv->total_colors;
  52.  
  53.     /* color_prom now points to the beginning of the character color codes */
  54.     color_codes = color_prom;    /* we'll need it later */
  55. }
  56.  
  57.  
  58.  
  59. WRITE_HANDLER( kyugo_gfxctrl_w )
  60. {
  61.     /* bit 0 is scroll MSB */
  62.     kyugo_back_scrollY_hi = data & 0x01;
  63.  
  64.     /* bit 5 is front layer color (Son of Phoenix only) */
  65.     frontcolor = (data & 0x20) >> 5;
  66.  
  67.     /* bit 6 is background palette bank */
  68.     if (palbank != ((data & 0x40) >> 6))
  69.     {
  70.         palbank = (data & 0x40) >> 6;
  71.         memset(dirtybuffer,1,videoram_size);
  72.     }
  73.  
  74. if (data & 0x9e)
  75. {
  76.     char baf[40];
  77.     sprintf(baf,"%02x",data);
  78.     usrintf_showmessage(baf);
  79. }
  80. }
  81.  
  82.  
  83. WRITE_HANDLER( kyugo_flipscreen_w )
  84. {
  85.     if (flipscreen != (data & 0x01))
  86.     {
  87.         flipscreen = (data & 0x01);
  88.         memset(dirtybuffer,1,videoram_size);
  89.     }
  90. }
  91.  
  92.  
  93.  
  94. static void draw_sprites(struct osd_bitmap *bitmap)
  95. {
  96.     /* sprite information is scattered through memory */
  97.     /* and uses a portion of the text layer memory (outside the visible area) */
  98.     unsigned char *spriteram_area1 = &spriteram[0x28];
  99.     unsigned char *spriteram_area2 = &spriteram_2[0x28];
  100.     unsigned char *spriteram_area3 = &kyugo_videoram[0x28];
  101.  
  102.     int n;
  103.  
  104.     for( n = 0; n < 12*2; n++ )
  105.     {
  106.         int offs,y,sy,sx,color;
  107.  
  108.         offs = 2*(n % 12) + 64*(n / 12);
  109.  
  110.         sx = spriteram_area3[offs+1] + 256 * (spriteram_area2[offs+1] & 1);
  111.         if (sx > 320) sx -= 512;
  112.  
  113.         sy = 255 - spriteram_area1[offs];
  114.         if (flipscreen) sy = 240 - sy;
  115.  
  116.         color = spriteram_area1[offs+1] & 0x1f;
  117.  
  118.         for (y = 0;y < 16;y++)
  119.         {
  120.             int attr2,code,flipx,flipy;
  121.  
  122.             attr2 = spriteram_area2[offs + 128*y];
  123.             code = spriteram_area3[offs + 128*y];
  124.             if (attr2 & 0x01) code += 512;
  125.             if (attr2 & 0x02) code += 256;
  126.             flipx =  attr2 & 0x08;
  127.             flipy =  attr2 & 0x04;
  128.             if (flipscreen)
  129.             {
  130.                 flipx = !flipx;
  131.                 flipy = !flipy;
  132.             }
  133.  
  134.             drawgfx( bitmap, Machine->gfx[1],
  135.                      code,
  136.                      color,
  137.                      flipx,flipy,
  138.                      sx,flipscreen ? sy - 16*y : sy + 16*y,
  139.                      &Machine->drv->visible_area,TRANSPARENCY_PEN, 0 );
  140.          }
  141.     }
  142. }
  143.  
  144.  
  145.  
  146. void kyugo_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  147. {
  148.     int offs;
  149.  
  150.  
  151.     /* back layer */
  152.     for( offs = videoram_size - 1;offs >= 0;offs-- )
  153.     {
  154.         if ( dirtybuffer[offs] )
  155.         {
  156.             int sx,sy,tile,flipx,flipy;
  157.  
  158.             dirtybuffer[offs] = 0;
  159.  
  160.             sx = offs % 64;
  161.             sy = offs / 64;
  162.             flipx = colorram[offs] & 0x04;
  163.             flipy = colorram[offs] & 0x08;
  164.             if (flipscreen)
  165.             {
  166.                 sx = 63 - sx;
  167.                 sy = 31 - sy;
  168.                 flipx = !flipx;
  169.                 flipy = !flipy;
  170.             }
  171.  
  172.             tile = videoram[offs] + ( 256 * ( colorram[offs] & 3 ) );
  173.  
  174.             drawgfx( tmpbitmap, Machine->gfx[2],
  175.                     tile,
  176.                     ((colorram[offs] & 0xf0) >> 4) + (palbank << 4),
  177.                     flipx,flipy,
  178.                     8*sx, 8*sy,
  179.                     0,TRANSPARENCY_NONE, 0 );
  180.         }
  181.     }
  182.  
  183.     {
  184.         int scrollx,scrolly;
  185.  
  186.         if (flipscreen)
  187.         {
  188.             scrollx = -32 - ( ( kyugo_back_scrollY_lo[0] ) + ( kyugo_back_scrollY_hi * 256 ) );
  189.             scrolly = kyugo_back_scrollX[0];
  190.         }
  191.         else
  192.         {
  193.             scrollx = -32 - ( ( kyugo_back_scrollY_lo[0] ) + ( kyugo_back_scrollY_hi * 256 ) );
  194.             scrolly = -kyugo_back_scrollX[0];
  195.         }
  196.  
  197.         /* copy the temporary bitmap to the screen */
  198.         copyscrollbitmap(bitmap,tmpbitmap,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  199.     }
  200.  
  201.     /* sprites */
  202.     draw_sprites(bitmap);
  203.  
  204.     /* front layer */
  205.     for( offs = kyugo_videoram_size - 1;offs >= 0;offs-- )
  206.     {
  207.         int sx,sy,code;
  208.  
  209.         sx = offs % 64;
  210.         sy = offs / 64;
  211.         if (flipscreen)
  212.         {
  213.             sx = 35 - sx;
  214.             sy = 31 - sy;
  215.         }
  216.  
  217.         code = kyugo_videoram[offs];
  218.  
  219.         drawgfx( bitmap, Machine->gfx[0],
  220.                 code,
  221.                 2*color_codes[code/8] + frontcolor,
  222.                 flipscreen, flipscreen,
  223.                 8*sx, 8*sy,
  224.                 &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  225.     }
  226. }
  227.